package com.atguigu.tingshu.album.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.atguigu.tingshu.album.mapper.*;
import com.atguigu.tingshu.album.service.BaseCategoryService;
import com.atguigu.tingshu.common.cache.TsCache;
import com.atguigu.tingshu.model.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@SuppressWarnings({"all"})
public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, BaseCategory1> implements BaseCategoryService {

    @Autowired
    private BaseCategory1Mapper baseCategory1Mapper;

    @Autowired
    private BaseCategory2Mapper baseCategory2Mapper;

    @Autowired
    private BaseCategory3Mapper baseCategory3Mapper;


    @Autowired
    private BaseCategoryViewMapper baseCategoryViewMapper;

    @Autowired
    private BaseAttributeMapper baseAttributeMapper;


    /**
     * 获取基础分类列表
     * <p>
     * 此方法用于从数据库中获取分类信息，并将其组织成一个嵌套的JSON结构
     * 分类信息分为三个层级，每个层级的分类信息都包含其子分类
     *
     * @return 包含所有基础分类的JSON对象列表
     */
	/*
	@Override
	public List<JSONObject> getBaseCategoryList() {
	    // 创建一个ArrayList用于存储最终的JSON对象
	    ArrayList<JSONObject> category1Child = new ArrayList<>();
	    // 从数据库中获取所有基础分类视图对象
	    List<BaseCategoryView> categoryViewList = baseCategoryViewMapper.selectList(null);

	    // 将分类视图对象按一级分类ID分组
	    Map<Long, List<BaseCategoryView>> map1 = categoryViewList.stream()
	            .collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));

	    // 遍历一级分类分组
	    Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = map1.entrySet().iterator();
	    while (iterator.hasNext()){
	        Map.Entry<Long, List<BaseCategoryView>> next = iterator.next();
	        Long category1Id = next.getKey();
	        List<BaseCategoryView> category1ViewList = next.getValue();
	        String category1Name = category1ViewList.get(0).getCategory1Name();

	        // 创建一个JSON对象用于存储一级分类信息
	        JSONObject jsonObject1 = new JSONObject();
	        jsonObject1.put("categoryId",category1Id);
	        jsonObject1.put("categoryName",category1Name);

	        // 将一级分类视图对象按二级分类ID分组
	        Map<Long, List<BaseCategoryView>> map2 = category1ViewList.stream()
	                .collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));

	        // 创建一个ArrayList用于存储二级分类的JSON对象
	        ArrayList<JSONObject> category2Child = new ArrayList<>();
	        for (Map.Entry<Long, List<BaseCategoryView>> next2 : map2.entrySet()) {
	            Long category2Id = next2.getKey();
	            List<BaseCategoryView> category2ViewList = next2.getValue();
	            String category2Name = category2ViewList.get(0).getCategory2Name();

	            // 创建一个JSON对象用于存储二级分类信息
	            JSONObject jsonObject2 = new JSONObject();
	            jsonObject2.put("categoryId",category2Id);
	            jsonObject2.put("categoryName",category2Name);

	            // 将二级分类视图对象转换为三级分类的JSON对象列表
	            List<JSONObject> category3Child = category2ViewList.stream().map(categoryView -> {
	                Long category3Id = categoryView.getCategory3Id();
	                String category3Name = categoryView.getCategory3Name();
	                JSONObject jsonObject3 = new JSONObject();
	                jsonObject3.put("categoryId", category3Id);
	                jsonObject3.put("categoryName", category3Name);
	                return jsonObject3;
	            }).collect(Collectors.toList());

	            // 将三级分类的JSON对象列表添加到二级分类的JSON对象中
	            jsonObject2.put("categoryChild", category3Child);
	            // 将二级分类的JSON对象添加到二级分类列表中
	            category2Child.add(jsonObject2);
	        }

	        // 将二级分类列表添加到一级分类的JSON对象中
	        jsonObject1.put("categoryChild",category2Child);
	        // 将一级分类的JSON对象添加到最终的列表中
	        category1Child.add(jsonObject1);
	    }

	    // 返回包含所有基础分类的JSON对象列表
	    return category1Child;
	}*/
    @Override
    public List<JSONObject> getBaseCategoryList() {
        ArrayList<JSONObject> categoryChild1 = new ArrayList<>();
        List<BaseCategoryView> categoryViewList = baseCategoryViewMapper.selectList(null);
        Map<Long, List<BaseCategoryView>> map1 = categoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
        Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = map1.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, List<BaseCategoryView>> next = iterator.next();
            Long category1Id = next.getKey();
            List<BaseCategoryView> categoryVimeList2 = next.getValue();
            String category1Name = next.getValue().get(0).getCategory1Name();
            JSONObject jsonObject1 = new JSONObject();
            jsonObject1.put("categoryId", category1Id);
            jsonObject1.put("categoryName", category1Name);
            ArrayList<JSONObject> categoryChild2 = new ArrayList<>();
            Map<Long, List<BaseCategoryView>> map2 = categoryVimeList2.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
            for (Map.Entry<Long, List<BaseCategoryView>> next2 : map2.entrySet()) {
                Long category2Id = next2.getKey();
                List<BaseCategoryView> categoryVimeList3 = next2.getValue();
                String category2Name = next2.getValue().get(0).getCategory2Name();
                JSONObject jsonObject2 = new JSONObject();
                jsonObject2.put("categoryId", category2Id);
                jsonObject2.put("categoryName", category2Name);
                List<JSONObject> category3Child = categoryVimeList3.stream().map(baseCategoryView -> {
                    Long category3Id = baseCategoryView.getCategory3Id();
                    String category3Name = baseCategoryView.getCategory3Name();
                    JSONObject jsonObject3 = new JSONObject();
                    jsonObject3.put("categoryId", category3Id);
                    jsonObject3.put("categoryName", category3Name);
                    return jsonObject3;
                }).collect(Collectors.toList());
                jsonObject2.put("categoryChild", category3Child);
                categoryChild2.add(jsonObject2);
            }
            jsonObject1.put("categoryChild", categoryChild2);
            categoryChild1.add(jsonObject1);
        }
        return categoryChild1;
    }

    /**
     * 调用Mapper查询属性和属性值信息
     *
     * @param category1Id
     * @return
     */
    @Override
    public List<BaseAttribute> findAttributeByCategory1Id(Long category1Id) {
        return baseAttributeMapper.selectBaseAttributeList(category1Id);
    }

    /**
     * 根据三级id获取分类信息
     *
     * @param category3Id
     * @return
     */
    @TsCache(prefix = "category:")
    @Override
    public BaseCategoryView getCategoryViewByCategory3Id(Long category3Id) {
        return baseCategoryViewMapper.selectById(category3Id);
    }

    /**
     * 获取所有类别列表
     * 此方法旨在根据给定的一级类别ID，构建一个包含该类别下所有子类别的JSON对象
     * 它不仅包含了一级类别的信息，还包含了属于该一级类别的二级类别，以及每个二级类别下的所有三级类别
     *
     * @param category1Id 一级类别ID，用于查询特定类别及其子类别
     * @return 返回包含所有子类别的JSON对象，如果查询或构建过程中出现异常，可能返回null
     */
    @Override
    public JSONObject getAllCategoryList(Long category1Id) {
        // 根据一级类别ID查询一级类别信息
        BaseCategory1 baseCategory1 = baseCategory1Mapper.selectById(category1Id);
        // 初始化一级类别JSON对象，用于存储一级类别及其子类别的信息
        JSONObject category1 = new JSONObject();
        category1.put("categoryId", category1Id);
        category1.put("categoryName", baseCategory1.getName());

        // 查询属于给定一级类别ID的所有视图信息，这些信息包含了二级和三级类别的映射
        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(
                new LambdaQueryWrapper<BaseCategoryView>().eq(BaseCategoryView::getCategory1Id, category1Id));
        // 将查询结果根据二级类别ID进行分组，以便后续处理
        Map<Long, List<BaseCategoryView>> category2Map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));

        // 初始化用于存储二级类别及其子类别的列表
        ArrayList<JSONObject> category2Child = new ArrayList<>();
        // 遍历二级类别分组
        Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = category2Map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, List<BaseCategoryView>> entry = iterator.next();
            Long category2Id = entry.getKey();
            List<BaseCategoryView> categoryViewList = entry.getValue();

            // 初始化二级类别JSON对象
            JSONObject category2 = new JSONObject();
            category2.put("categoryId",category2Id);
            category2.put("categoryName",categoryViewList.get(0).getCategory2Name());

            // 将二级类别下的三级类别信息构建为JSON对象列表
            List<JSONObject> list = categoryViewList.stream().map(m -> {
                JSONObject category3 = new JSONObject();
                category3.put("categoryId", m.getCategory3Id());
                category3.put("categoryName", m.getCategory3Name());
                return category3;
            }).toList();

            // 将三级类别信息列表添加到二级类别对象中，并将二级类别对象添加到子类别列表中
            category2.put("categoryChild",list);
            category2Child.add(category2);
        }

        // 将二级类别及其子类别列表添加到一级类别对象中
        category1.put("categoryChild", category2Child);

        // 此处应返回构建好的一级类别及其子类别信息的JSON对象
        return category1;
    }

    /**
     * 根据类别1的ID查找顶级类别3的商品列表
     *
     * @param category1Id 类别1的ID
     * @return 返回顶级的类别3商品列表，最多7个
     */
    @Override
    public List<BaseCategory3> findTopBaseCategory3ByCategory1Id(Long category1Id) {
        // 查询类别2列表，这些类别2属于类别1
        List<Long> category2Id = baseCategory2Mapper.selectList(new LambdaQueryWrapper<BaseCategory2>().eq(BaseCategory2::getCategory1Id, category1Id)).stream().map(BaseCategory2::getId).collect(Collectors.toList());

        // 查询顶级的类别3列表，这些类别3属于类别2，并且设置为顶级（isTop=1），最多获取7条记录
        List<BaseCategory3> baseCategory3List = baseCategory3Mapper.selectList(new LambdaQueryWrapper<BaseCategory3>().in(BaseCategory3::getCategory2Id, category2Id).eq(BaseCategory3::getIsTop, 1).last(" limit 7 "));

        // 返回查询到的类别3列表
        return baseCategory3List;
    }

    @Override
    public List<BaseCategory1> findAllCategory1() {
        return baseCategory1Mapper.selectList(null);
    }
}
